// 解题思路：
// 迷宫问题 - 找最短路径
// 因为可以上下左右四个方向移动，所以不能使用动态规划
// 如果使用动态规划 dp[i][j] = min(dp[i - 1][j], dp[i + 1][j], dp[i][j - 1], dp[i][j + 1]) + 1
// 这个填表方向是错误的，不管从上面填还是从下面填，都无法填表
// 这种四个方向找最短路径的问题，就类似于多源 bfs 问题，最好是用 bfs 求解

// bfs 思路：
// 从起点开始，一层一层向外扩展，将每一层的点都加入队列中
// 每扩展一层，实际上就走了一步 ret++
// 直到找到终点，返回 ret

import java.util.*;

public class ShortestPath {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int n = in.nextInt(); int m = in.nextInt();
        int[] s = new int[2]; int[] t = new int[2];
        s[0] = in.nextInt(); s[1] = in.nextInt();
        t[0] = in.nextInt(); t[1] = in.nextInt();
        char[][] arr = new char[n][m];
        for(int i = 0; i < n; i++) arr[i] = in.next().toCharArray();
        boolean[][] check = new boolean[n + 1][m + 1];
        int[] dx = {0, 0, 1, -1};
        int[] dy = {1, -1, 0, 0};
        int ret = 0;
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(s);
        check[s[0]][s[1]] = true;
        while(!queue.isEmpty()){
            int size = queue.size();
            ret++;
            while(size-- > 0){
                int[] point = queue.poll();
                int i = point[0];
                int j = point[1];
                for(int k = 0; k < 4; k++){
                    int x = i + dx[k];
                    int y = j + dy[k];
                    if(x >= 1 && x <= n && y >= 1 && y <= m && !check[x][y] && arr[x - 1][y - 1] == '.'){
                        queue.offer(new int[] {x, y});
                        check[x][y] = true;
                        if(x == t[0] && y == t[1]){
                            System.out.println(ret);
                            return;
                        }
                    }
                }
            }
        }
        System.out.println(-1);
    }
}
